"""
配置管理模块
用于加载、保存和管理应用程序的配置信息，包括API密钥和可用的LLM模型
"""
import json
import os
import sys  

# 将项目根目录添加到Python路径
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

from core.logger import get_logger

# 初始化日志记录器
logger = get_logger("config_manager")

# 配置文件路径常量
CONFIG_FILE = "config/config.json"

def load_config():
    """
    加载配置文件
    
    从CONFIG_FILE指定的路径加载JSON配置。
    如果文件不存在，则创建包含默认设置的新配置文件。
    
    返回值:
        dict: 包含应用程序配置的字典
    """
    try:
        if os.path.exists(CONFIG_FILE):
            # 如果配置文件存在，则从中加载数据
            with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 如果配置文件不存在，创建默认配置
            default_config = {
                "api_keys": {
                    "qwen": "",  # 默认空API密钥
                    "deepseek": "",
                    "seatable": ""
                },
                "available_models": [
                    {
                        "id": 1,
                        "name": "qwen3-235b-a22b",
                        "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
                        "provider": "qwen",
                        "description": "通义千问大语言模型"
                    },
                    {
                        "id": 2,
                        "name": "deepseek-chat",
                        "base_url": "https://api.deepseek.com",
                        "provider": "deepseek",
                        "description": "DeepSeek    v3大语言模型"
                    },
                    {
                        "id": 3,
                        "name": "deepseek-reasoner",
                        "base_url": "https://api.deepseek.com",
                        "provider": "deepseek",
                        "description": "DeepSeek 推理大语言模型"
                    }
                ],
                "default_model_id": 1,  # 默认模型ID
                "mcp_config": {
                    "mcpServers": {
                        "default_server": {
                            "url": ""
                        },
                        "custom_server": {
                            "name": "自定义MCP服务器",
                            "type": "stdio",
                            "description": "",
                            "isActive": False,
                            "registryUrl": "",
                            "command": "",
                            "args": []
                        }
                    }
                }
            }
            save_config(default_config)  # 保存默认配置
            logger.warning(f"配置文件 {CONFIG_FILE} 不存在，已创建默认配置文件")
            return default_config
    except Exception as e:
        # 错误处理：返回最小可用配置
        logger.error(f"加载配置文件出错: {str(e)}")
        return {"api_keys": {"deepseek": ""}, "available_models": [], "default_model_id": 1}

def save_config(config):
    """
    保存配置到配置文件
    
    将配置字典保存到CONFIG_FILE指定的JSON文件中
    
    参数:
        config (dict): 要保存的配置字典
    """
    try:
        # 将配置写入JSON文件，使用UTF-8编码并美化格式
        with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
            json.dump(config, f, ensure_ascii=False, indent=4)
        logger.info(f"配置已保存到 {CONFIG_FILE}")
    except Exception as e:
        logger.error(f"保存配置文件出错: {str(e)}")

def get_api_key(provider="deepseek"):
    """
    获取指定提供商的API密钥
    
    从配置中获取特定AI服务提供商的API密钥
    
    参数:
        provider (str): 服务提供商名称，默认为"deepseek"
        
    返回值:
        str: 指定提供商的API密钥，如果未找到则为空字符串
    """
    config = load_config()                                  # 加载当前配置
   
    api_key = config.get("api_keys", {}).get(provider, "")  # 获取指定提供商的API密钥，不存在则返回空字符串
    
    if not api_key:
        logger.warning(f"在配置文件中未找到 {provider} 的API密钥")
    
    return api_key 

def get_available_models():
    """
    获取可用的模型列表
    
    返回配置中定义的所有可用LLM模型
    
    返回值:
        list: 包含模型信息字典的列表
    """
    config = load_config()
    return config.get("available_models", [])  # 如果键不存在则返回空列表

def get_default_model():
    """
    获取默认模型
    
    根据配置中的default_model_id获取默认模型
    
    返回值:
        dict|None: 默认模型信息字典，如果无默认模型则返回None
    """
    config = load_config()
    default_id = config.get("default_model_id", 1)
    models = config.get("available_models", [])
    
    for model in models:
        if model.get("id") == default_id:
            return model
    
    # 如果未找到默认ID的模型，返回第一个模型或None
    return None if not models else models[0]

def get_model(model_id=None, model_name=None):
    """
    获取指定模型或默认模型
    
    根据模型ID或模型名称获取LLM模型信息。如果两者都未指定，则返回默认模型。
    如果未找到指定模型，则返回默认模型或第一个可用模型或None
    
    参数:
        model_id (int, optional): 模型ID
        model_name (str, optional): 模型名称
        
    返回值:
        dict|None: 模型信息字典，如果无可用模型则返回None
    """
    config = load_config()
    models = config.get("available_models", [])  # 获取所有可用模型
    
    # 根据ID查找模型
    if model_id is not None:
        for model in models:
            if model.get("id") == model_id:
                return model
    
    # 根据名称查找模型
    if model_name is not None:
        for model in models:
            if model.get("name") == model_name:
                return model
    
    # 如果未指定ID或名称，或未找到指定模型，返回默认模型
    default_id = config.get("default_model_id", 1)
    for model in models:
        if model.get("id") == default_id:
            return model
    
    # 如果未找到默认ID的模型，返回第一个模型或None
    return None if not models else models[0]

def get_mcp_config():
    """
    获取MCP配置
    
    从配置中获取MCP服务器配置信息
    
    返回值:
        dict: MCP配置信息，如果不存在则返回空字典
    """
    config = load_config()
    return config.get("mcp_config", {"mcpServers": {}})

def get_mcp_server(server_id=None):
    """
    获取指定MCP服务器配置
    
    根据服务器ID获取特定MCP服务器的配置信息
    
    参数:
        server_id (str, optional): 服务器ID，如果为None则返回第一个可用服务器
        
    返回值:
        tuple: (server_id, server_config) 服务器ID和配置信息，如果未找到则为(None, None)
    """
    mcp_config = get_mcp_config()
    servers = mcp_config.get("mcpServers", {})
    
    if not servers:
        return None, None
    
    if server_id is not None and server_id in servers:
        return server_id, servers[server_id]
    
    # 返回第一个服务器
    first_server_id = next(iter(servers))
    return first_server_id, servers[first_server_id]


# 模块直接运行时的测试代码
if __name__ == '__main__':

    # # 测试加载、创建配置文件
    # print(load_config())

    # # 测试保存配置文件
    # config = load_config()
    # config["api_keys"]["deepseek"] = "sk-2dc3054897024436ad47912a07ef4617"
    # save_config(config)

    # 测试获取API密钥
    api_key = get_api_key("deepseek")
    print(f"API key: '{api_key}'")  

    # # 测试获取可用模型列表
    # models = get_available_models()
    # print(models)

    # # 测试获取指定模型
    # model = get_model(model_name="deepseek-reasoner")
    # print(model)


    # # 测试获取MCP配置
    # mcp_config = get_mcp_config()
    # print(mcp_config)


    # # 测试获取指定MCP服务器
    # server_id, server_config = get_mcp_server(server_id="GYCDWcq578JMgRTd34B0_")
    # print(server_id, server_config)



